home *** CD-ROM | disk | FTP | other *** search
/ Resource Library: Multimedia / Resource Library: Multimedia.iso / maestro / source / videbjct / videoobj.c < prev    next >
Encoding:
C/C++ Source or Header  |  1993-06-15  |  27.7 KB  |  1,171 lines
  1. /*
  2.  * Copyright (c) 1990, 1991, 1992 Stanford University
  3.  *
  4.  * Permission to use, copy, modify, and distribute this software and 
  5.  * its documentation for any purpose is hereby granted without fee, provided
  6.  * that (i) the above copyright notices and this permission notice appear in
  7.  * all copies of the software and related documentation, and (ii) the name
  8.  * Stanford may not be used in any advertising or publicity relating to
  9.  * the software without the specific, prior written permission of
  10.  * Stanford.
  11.  * 
  12.  * THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND, 
  13.  * EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY 
  14.  * WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.  
  15.  *
  16.  * IN NO EVENT SHALL STANFORD BE LIABLE FOR ANY SPECIAL, INCIDENTAL,
  17.  * INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND, OR ANY DAMAGES
  18.  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER OR NOT
  19.  * ADVISED OF THE POSSIBILITY OF DAMAGE, AND ON ANY THEORY OF LIABILITY,
  20.  * ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
  21.  * SOFTWARE.
  22.  */
  23.  
  24. /* $Header: /Source/Media/collab/VideoObject/RCS/videoObj.c,v 0.29 92/09/02 17:09:43 drapeau Exp $ */
  25. /* $Log:    videoObj.c,v $
  26.  * Revision 0.29  92/09/02  17:09:43  drapeau
  27.  * Fixed code for determining what terminal parameters to use for serial
  28.  * communications, especially when parity and flow control are concerned.
  29.  * Previous versions of this code did not handle flow control and parity
  30.  * correctly.
  31.  * 
  32.  * Revision 0.28  92/09/01  16:58:10  drapeau
  33.  * Cosmetic changes to the code to make it easier to read.  Also, added
  34.  * function prototypes to make code more ANSI-compliant.
  35.  * 
  36.  * Revision 0.27  92/07/30  15:14:46  drapeau
  37.  * Removed window system-specific code, to make library more portable.
  38.  * Also, minor cosmetic changes to enhance code readability.
  39.  * Also, minor changes to diagnostic messages to improve readability.
  40.  * 
  41.  * Revision 0.26  92/06/17  01:01:58  drapeau
  42.  * Changed termio usage, used more portable "termio" structure and
  43.  * associated calls instead of "termios".
  44.  * 
  45.  * Revision 0.25  91/09/30  17:08:58  lim
  46.  * Implemented DevPing, DefaultPing, PlayerVerified.
  47.  * 
  48.  * Revision 0.24  91/08/24  17:50:28  lim
  49.  * Implemented PrintDiagnostics.
  50.  * 
  51.  * Revision 0.23  91/08/24  13:52:13  lim
  52.  * CheckImplemented corrected to return an enum Boolean.
  53.  * 
  54.  * Revision 0.22  91/08/24  13:39:20  lim
  55.  * 1. Clear Marker() removed as part of video Object.
  56.  * 
  57.  * Revision 0.21  91/08/20  10:06:41  lim
  58.  * Removed InterruptibleSegmentPlay from BuildVideoObject.
  59.  * 
  60.  * Revision 0.20  91/08/17  20:42:08  lim
  61.  * 1. Removed 'interruptibleSegmentPlay' from video object. All stops and
  62.  * pauses must be implemented such that they can interrupt segment play.
  63.  * 
  64.  * Revision 0.19  91/08/16  13:14:52  lim
  65.  * Each Dev<Function> call now checks if theObject is valid.
  66.  * 
  67.  * Revision 0.18  91/08/08  17:19:37  lim
  68.  * 1. CalcSpeed() - one parameter added, 'playMode'. If playMode is 1, it is used to calculate
  69.  *    device speed for segment play. If playMode is 0, it is used to calculate device speed for
  70.  *    normal play.
  71.  * 2. QueryMedium() - one parameter added, 'result'. Used to return non-integer results.
  72.  * 
  73.  * Revision 0.17  91/08/07  13:30:24  lim
  74.  * 1. Added instance pointer, "theObject" to all public function calls.
  75.  * 2. Added file descriptor field to structure 'Config'.
  76.  * 3. ErrorDecode is now a private function, and thus removed from the
  77.  * VideoObject.
  78.  * 4. BuildVideoObject now returns pointer to VideoObject.
  79.  * 
  80.  * Revision 0.16  91/08/02  13:02:53  lim
  81.  * 1. No more GetDevices - Device configurations stored in each device's
  82.  * videoObject, and names of all devices stored in allDevices.
  83.  * 2. 'myVideo' is now globally accessible.
  84.  * 3. SetSerialLine changed to take in device configuration structure as
  85.  * first parameter rather than device name.
  86.  * 4. BuildVideoObject changed to include new field in videoObject - the
  87.  * configuration.
  88.  * 5. Pause() has been removed from videoObject's functions.
  89.  * 6. Added : GetDeviceMaxSpeed - gets the max speed on current device.
  90.  *            CheckImplemented - checks if particular function available on
  91.  *                               current device.
  92.  * 7. DevSetDefaults now takes 4 parameters.
  93.  * 
  94.  * Revision 0.15  91/07/29  22:31:57  lim
  95.  * When there is no eol char, the line will be set up to 
  96.  * 1. Ignore carriage return IGNCR
  97.  * 2. Non-canonical input
  98.  * 3. c_cc[VMIN] is set to default 1, and c_cc[VTIME] to 0.
  99.  * 
  100.  * Revision 0.14  91/07/27  22:30:05  lim
  101.  * Changed speed from double to int.
  102.  * 
  103.  * Revision 0.13  91/07/23  15:59:47  lim
  104.  * 1. Changed static variables to globals.
  105.  * 2. Introduced a new field, interruptibleSegmentPlay, in the .VideoConfig
  106.  * file, to denote whether device supports interruptible segment playing.
  107.  * 
  108.  * 
  109.  * Revision 0.12  91/07/19  14:16:11  lim
  110.  * Added speed field to PlayFromTo.
  111.  * 
  112.  * Revision 0.11  91/07/17  22:50:55  lim
  113.  * Removed function from VideoObject, "SetSerialPort". 
  114.  * 
  115.  * Revision 0.10  91/07/12  16:22:36  lim
  116.  * Initial revision implementing VideoObject.
  117.  *  */
  118.  
  119. #include "videoObj.h"
  120.  
  121.  
  122. static Config DefaultConfig = 
  123. {
  124.   "NOTHING",
  125.   "na",
  126.   0,
  127.   -1,
  128.   -1,
  129.   Even,
  130.   Yes,
  131.   Yes,
  132.   -1,
  133.   -1
  134.   }
  135. ; 
  136.  
  137.  
  138. static VideoObject DefaultObj = 
  139. {
  140.   &DefaultConfig,
  141.   DefaultPlay,
  142.   DefaultPlayFromTo,
  143.   DefaultFastForward,
  144.   DefaultReverse,
  145.   DefaultCalcSpeed,
  146.   DefaultPlayAtSpeedDir,
  147.   DefaultStep,
  148.   DefaultStill,
  149.   DefaultStop,
  150.   DefaultSetDefaults,
  151.   DefaultSetAudio,
  152.   DefaultSetVideo,
  153.   DefaultSetAddMode,
  154.   DefaultSetAddressDisplay,
  155.   DefaultEject,
  156.   DefaultPower,
  157.   DefaultQueryFrame,
  158.   DefaultQueryChapter,
  159.   DefaultQueryAudio,
  160.   DefaultQueryVideo,
  161.   DefaultQueryMedium,
  162.   DefaultQueryStatus,
  163.   DefaultPing,
  164.   DefaultRecord,
  165.   DefaultRecordFromTo
  166.   }
  167. ;
  168.  
  169.  
  170. /* Sets up serial line for device selected.  
  171.  * Returns file descriptor.
  172.  */
  173.  
  174. int
  175.   SetSerialLine(Config*    configuration,
  176.         char*    newSerialLine)
  177. {
  178.   int ibaud;
  179.   int bits;
  180.   int serialLine;
  181.   char diagMsg[30];
  182.   static struct termio lineAttributes;
  183.   
  184.   if (configuration->fd>=0)                        /* Close previous serial line */
  185.     close (configuration->fd);
  186.   
  187.   switch (configuration->baudRate) 
  188.   {
  189.    case 300:
  190.     ibaud = B300;
  191.     break;
  192.    case 1200:
  193.     ibaud = B1200;
  194.     break;
  195.    case 2400:
  196.     ibaud = B2400;
  197.     break;
  198.    case 4800:
  199.     ibaud = B4800;
  200.     break;
  201.    case 9600:
  202.     ibaud = B9600;
  203.     break;
  204.    default:
  205.     PrintDiagnostics("Illegal baud rate\n");
  206.   }
  207.   
  208.   switch (configuration->charSize)
  209.   {
  210.    case 5:
  211.     bits = CS5;
  212.     break;
  213.    case 6:
  214.     bits = CS6;
  215.     break;
  216.    case 7:
  217.     bits = CS7;
  218.     break;
  219.    case 8:
  220.     bits = CS8;
  221.     break;
  222.    default:
  223.     PrintDiagnostics("Illegal character size\n");
  224.   }
  225.   
  226.   /* Open serial line */
  227.   
  228.   if (newSerialLine)                            /* newSerialLine overrides all other settings */
  229.     strcpy(configuration->serialPort, newSerialLine);
  230.   else
  231.     PrintDiagnostics("No entry in defaults file.\n");
  232.   
  233.   if ((serialLine = open(configuration->serialPort, O_RDWR)) == -1) 
  234.     PrintDiagnostics("VideoObject: Cannot open serial line for communications.\n");
  235.   
  236.   lineAttributes.c_iflag = 0;
  237.   if (configuration->flowControl == Yes)
  238.   {
  239.     lineAttributes.c_iflag |= IXON;
  240.     lineAttributes.c_iflag |= IXOFF;
  241.   }
  242.   if (configuration->igParError == Yes)
  243.     lineAttributes.c_iflag |= IGNPAR;
  244.   if (configuration->parity != NoParity)
  245.     lineAttributes.c_iflag |= INPCK;
  246.   if (configuration->eolChar < 0)
  247.     lineAttributes.c_iflag |= IGNCR;
  248.   
  249.   lineAttributes.c_oflag = 0;
  250.   lineAttributes.c_lflag = 0;
  251.   if (configuration->eolChar >= 0)                    /* Canonical input processing only if there is a eol char */
  252.     lineAttributes.c_lflag |= ICANON;
  253.   lineAttributes.c_line = 0;
  254.   
  255.   if (configuration->eolChar >= 0)                    /* Player has end-of-line character */
  256.     lineAttributes.c_cc[VEOL] = configuration->eolChar;
  257.   else                                    /* Player has no end-of-line character */
  258.   {
  259.     lineAttributes.c_cc[VMIN] = 1;
  260.     lineAttributes.c_cc[VTIME] = 0;
  261.   }
  262.   
  263.   lineAttributes.c_cflag = 0;
  264.   lineAttributes.c_cflag |= ibaud;
  265.   lineAttributes.c_cflag |= bits;
  266.   lineAttributes.c_cflag |= CLOCAL;
  267.   lineAttributes.c_cflag |= CREAD;
  268.   if (configuration->parity != NoParity)
  269.     lineAttributes.c_cflag |= PARENB;
  270.   if (configuration->parity == Odd)
  271.     lineAttributes.c_cflag |= PARODD;
  272.   
  273.   if (ioctl(serialLine,TCSETA,(char*)&lineAttributes) == -1) 
  274.     PrintDiagnostics("Can't set line attributes.\n");
  275.   
  276.   configuration->fd = serialLine;
  277.   return serialLine;
  278. }                                    /* end function SetSerialLine */
  279.  
  280.  
  281. /* To test if player & serial port are correctly selected.
  282.  * A serial line is set up so that it does non-canonical input
  283.  * processing, with a timer set to TimeOut seconds, and the read returning
  284.  * after the first character is read. 
  285.  * The function DevPing() is called for the object installed.
  286.  * If DevPing() returns a positive number, it means that the device is
  287.  * correct, and PlayerVerified returns 1.  
  288.  * If DevPing() returns 0 or a negative number, it means that the read 
  289.  * has timed out, and either the player is too busy to respond, or the
  290.  * wrong player has been selected, or the wrong serial port has been 
  291.  * selected, or the wrong line attributes (eg baud rate) have been set. 
  292.  * In this case, PlayerVerified returns -1.
  293.  */
  294. int
  295. PlayerVerified(VideoObject*    theObject,
  296.            char*        sLine)
  297. {
  298.   struct termio    lineAttributes;
  299.   int        numRead;
  300.   int        eolChar;                                
  301.   int        result = 0;
  302.   char        out[5];
  303.   
  304.   eolChar = theObject->DevConfig->eolChar;                /* We must keep tmp copy of eolChar */
  305.   theObject->DevConfig->eolChar = -1;                    /* For non-canonical processing */
  306.   
  307.   if (SetSerialLine(theObject->DevConfig, sLine))
  308.   {
  309.     result = ioctl(theObject->DevConfig->fd,TCGETA,
  310.            (char*)&lineAttributes);
  311.     lineAttributes.c_cc[VMIN] = 0;
  312.     lineAttributes.c_cc[VTIME] = TimeOut*10;                /* VTIME is in 0.1 seconds */
  313.     result = ioctl(theObject->DevConfig->fd,TCSETA,
  314.            (char*)&lineAttributes);
  315.     if (result == -1)
  316.       return -1;
  317.     
  318.     numRead = DevPing(theObject);
  319.     close(theObject->DevConfig->fd);
  320.     theObject->DevConfig->fd = -1;                    /* Reset file descriptor */
  321.     theObject->DevConfig->eolChar = eolChar;                /* Reset eolChar */
  322.     
  323.     if (numRead > 0)
  324.       return 1;
  325.     else
  326.       return -1;
  327.   }
  328.   else
  329.     return -1;
  330. }
  331.  
  332.  
  333. /* Builds the Video Object for use by application.
  334.  * A copy of the defined functions in the new device ...
  335.  * ... is made to theObject.
  336.  */
  337.  
  338. VideoObject* 
  339.   BuildVideoObject(VideoObject* videoObj)
  340. {
  341.   VideoObject* newObj;
  342.   
  343.   newObj = (VideoObject*) malloc(sizeof(VideoObject));
  344.   newObj->DevConfig = (Config*) malloc(sizeof(Config));
  345.   
  346.   strcpy(newObj->DevConfig->serialPort, videoObj->DevConfig->serialPort);
  347.   strcpy(newObj->DevConfig->modelName, videoObj->DevConfig->modelName);
  348.   newObj->DevConfig->baudRate = videoObj->DevConfig->baudRate;
  349.   newObj->DevConfig->eolChar = videoObj->DevConfig->eolChar;
  350.   newObj->DevConfig->charSize = videoObj->DevConfig->charSize;
  351.   newObj->DevConfig->parity = videoObj->DevConfig->parity;
  352.   newObj->DevConfig->igParError = videoObj->DevConfig->igParError;
  353.   newObj->DevConfig->maxSpeed = videoObj->DevConfig->maxSpeed;
  354.   newObj->DevConfig->fd = videoObj->DevConfig->fd;
  355.   
  356.   if (videoObj->DevPlayPtr)
  357.     newObj->DevPlayPtr =  videoObj->DevPlayPtr; 
  358.   else
  359.     newObj->DevPlayPtr =  DefaultObj.DevPlayPtr; 
  360.   
  361.   if (videoObj->DevPlayFromToPtr)
  362.     newObj->DevPlayFromToPtr =  videoObj->DevPlayFromToPtr; 
  363.   else
  364.     newObj->DevPlayFromToPtr =  DefaultObj.DevPlayFromToPtr; 
  365.   
  366.   if (videoObj->DevFastForwardPtr)
  367.     newObj->DevFastForwardPtr =  videoObj->DevFastForwardPtr; 
  368.   else
  369.     newObj->DevFastForwardPtr =  DefaultObj.DevFastForwardPtr; 
  370.   
  371.   if (videoObj->DevReversePtr)
  372.     newObj->DevReversePtr =  videoObj->DevReversePtr; 
  373.   else
  374.     newObj->DevReversePtr =  DefaultObj.DevReversePtr; 
  375.   
  376.   if (videoObj->DevCalcSpeedPtr)
  377.     newObj->DevCalcSpeedPtr =  videoObj->DevCalcSpeedPtr; 
  378.   else
  379.     newObj->DevCalcSpeedPtr =  DefaultObj.DevCalcSpeedPtr; 
  380.   
  381.   if (videoObj->DevPlayAtSpeedDirPtr)
  382.     newObj->DevPlayAtSpeedDirPtr =  videoObj->DevPlayAtSpeedDirPtr; 
  383.   else
  384.     newObj->DevPlayAtSpeedDirPtr =  DefaultObj.DevPlayAtSpeedDirPtr; 
  385.   
  386.   if (videoObj->DevStepPtr)
  387.     newObj->DevStepPtr =  videoObj->DevStepPtr; 
  388.   else
  389.     newObj->DevStepPtr =  DefaultObj.DevStepPtr; 
  390.   
  391.   if (videoObj->DevStillPtr)
  392.     newObj->DevStillPtr =  videoObj->DevStillPtr; 
  393.   else
  394.     newObj->DevStillPtr =  DefaultObj.DevStillPtr; 
  395.   
  396.   if (videoObj->DevStopPtr)
  397.     newObj->DevStopPtr =  videoObj->DevStopPtr; 
  398.   else
  399.     newObj->DevStopPtr =  DefaultObj.DevStopPtr; 
  400.   
  401.   if (videoObj->DevSetDefaultsPtr)
  402.     newObj->DevSetDefaultsPtr =  videoObj->DevSetDefaultsPtr; 
  403.   else
  404.     newObj->DevSetDefaultsPtr =  DefaultObj.DevSetDefaultsPtr; 
  405.   
  406.   if (videoObj->DevSetAudioPtr)
  407.     newObj->DevSetAudioPtr =  videoObj->DevSetAudioPtr; 
  408.   else
  409.     newObj->DevSetAudioPtr =  DefaultObj.DevSetAudioPtr; 
  410.   
  411.   if (videoObj->DevSetVideoPtr)
  412.     newObj->DevSetVideoPtr =  videoObj->DevSetVideoPtr;
  413.   else
  414.     newObj->DevSetVideoPtr =  DefaultObj.DevSetVideoPtr;
  415.   
  416.   if (videoObj->DevSetAddModePtr)
  417.     newObj->DevSetAddModePtr =  videoObj->DevSetAddModePtr;
  418.   else
  419.     newObj->DevSetAddModePtr =  DefaultObj.DevSetAddModePtr;
  420.   
  421.   if (videoObj->DevSetAddressDisplayPtr)
  422.     newObj->DevSetAddressDisplayPtr =  videoObj->DevSetAddressDisplayPtr; 
  423.   else
  424.     newObj->DevSetAddressDisplayPtr =  DefaultObj.DevSetAddressDisplayPtr; 
  425.   
  426.   if (videoObj->DevEjectPtr)
  427.     newObj->DevEjectPtr =  videoObj->DevEjectPtr;
  428.   else
  429.     newObj->DevEjectPtr =  DefaultObj.DevEjectPtr;
  430.   
  431.   if (videoObj->DevPowerPtr)
  432.     newObj->DevPowerPtr =  videoObj->DevPowerPtr; 
  433.   else
  434.     newObj->DevPowerPtr =  DefaultObj.DevPowerPtr; 
  435.   
  436.   if (videoObj->DevQueryFramePtr)
  437.     newObj->DevQueryFramePtr =  videoObj->DevQueryFramePtr; 
  438.   else
  439.     newObj->DevQueryFramePtr =  DefaultObj.DevQueryFramePtr; 
  440.   
  441.   if (videoObj->DevQueryChapterPtr)
  442.     newObj->DevQueryChapterPtr =  videoObj->DevQueryChapterPtr; 
  443.   else
  444.     newObj->DevQueryChapterPtr =  DefaultObj.DevQueryChapterPtr; 
  445.   
  446.   if (videoObj->DevQueryAudioPtr)
  447.     newObj->DevQueryAudioPtr =  videoObj->DevQueryAudioPtr; 
  448.   else
  449.     newObj->DevQueryAudioPtr =  DefaultObj.DevQueryAudioPtr; 
  450.   
  451.   if (videoObj->DevQueryVideoPtr)
  452.     newObj->DevQueryVideoPtr =  videoObj->DevQueryVideoPtr; 
  453.   else
  454.     newObj->DevQueryVideoPtr =  DefaultObj.DevQueryVideoPtr; 
  455.   
  456.   if (videoObj->DevQueryMediumPtr)
  457.     newObj->DevQueryMediumPtr =    videoObj->DevQueryMediumPtr; 
  458.   else
  459.     newObj->DevQueryMediumPtr =    DefaultObj.DevQueryMediumPtr; 
  460.   
  461.   if (videoObj->DevQueryStatusPtr)
  462.     newObj->DevQueryStatusPtr =  videoObj->DevQueryStatusPtr;
  463.   else
  464.     newObj->DevQueryStatusPtr =  DefaultObj.DevQueryStatusPtr;
  465.   
  466.   if (videoObj->DevPingPtr)
  467.     newObj->DevPingPtr =  videoObj->DevPingPtr;
  468.   else
  469.     newObj->DevPingPtr =  DefaultObj.DevPingPtr;
  470.   
  471.   if (videoObj->DevRecordPtr)
  472.     newObj->DevRecordPtr =  videoObj->DevRecordPtr;
  473.   else
  474.     newObj->DevRecordPtr =  DefaultObj.DevRecordPtr;
  475.   
  476.   if (videoObj->DevRecordFromToPtr)
  477.     newObj->DevRecordFromToPtr =  videoObj->DevRecordFromToPtr;
  478.   else
  479.     newObj->DevRecordFromToPtr =  DefaultObj.DevRecordFromToPtr;
  480.   
  481.   return (newObj);
  482. }                                    /* end function BuildVideoObject */
  483.  
  484.  
  485.  
  486. /* Returns the max speed for the current video device */
  487. int
  488.   GetDeviceMaxSpeed(VideoObject* theObject)
  489. {
  490.   if (theObject)
  491.     return (theObject->DevConfig->maxSpeed);
  492.   else 
  493.     return -1;
  494. }
  495.  
  496.  
  497. /* Checks to see if video object function 'func' has been implemented...
  498.  * ... in current video object */
  499. enum Boolean
  500.   CheckImplemented(VideoObject*    theObject,
  501.            int        func)
  502. {
  503.   switch (func)
  504.   {
  505.    case PlayFunction:
  506.     if (theObject->DevPlayPtr)
  507.       return Yes;
  508.     else
  509.       return No;
  510.    case PlayFromToFunction:
  511.     if (theObject->DevPlayFromToPtr)
  512.       return Yes;
  513.     else
  514.       return No;
  515.    case FastForwardFunction:
  516.     if (theObject->DevFastForwardPtr)
  517.       return Yes;
  518.     else
  519.       return No;
  520.    case ReverseFunction:
  521.     if (theObject->DevReversePtr)
  522.       return Yes;
  523.     else
  524.       return No;
  525.    case CalcSpeedFunction:
  526.     if (theObject->DevCalcSpeedPtr)
  527.       return Yes;
  528.     else
  529.       return No;
  530.    case PlayAtSpeedDirFunction:
  531.     if (theObject->DevPlayAtSpeedDirPtr)
  532.       return Yes;
  533.     else
  534.       return No;
  535.    case StepFunction:
  536.     if (theObject->DevStepPtr)
  537.       return Yes;
  538.     else
  539.       return No;
  540.    case StillFunction:
  541.     if (theObject->DevStillPtr)
  542.       return Yes;
  543.     else
  544.       return No;
  545.    case StopFunction:
  546.     if (theObject->DevStopPtr)
  547.       return Yes;
  548.     else
  549.       return No;
  550.    case SetDefaultsFunction:
  551.     if (theObject->DevSetDefaultsPtr)
  552.       return Yes;
  553.     else
  554.       return No;
  555.    case SetAudioFunction:
  556.     if (theObject->DevSetAudioPtr)
  557.       return Yes;
  558.     else
  559.       return No;
  560.    case SetVideoFunction:
  561.     if (theObject->DevSetVideoPtr)
  562.       return Yes;
  563.     else
  564.       return No;
  565.    case SetAddModeFunction:
  566.     if (theObject->DevSetAddModePtr)
  567.       return Yes;
  568.     else
  569.       return No;
  570.    case SetAddressDisplayFunction:
  571.     if (theObject->DevSetAddressDisplayPtr)
  572.       return Yes;
  573.     else
  574.       return No;
  575.    case EjectFunction:
  576.     if (theObject->DevEjectPtr)
  577.       return Yes;
  578.     else
  579.       return No;
  580.    case PowerFunction:
  581.     if (theObject->DevPowerPtr)
  582.       return Yes;
  583.     else
  584.       return No;
  585.    case QueryFrameFunction:
  586.     if (theObject->DevQueryFramePtr)
  587.       return Yes;
  588.     else
  589.       return No;
  590.    case QueryChapterFunction:
  591.     if (theObject->DevQueryChapterPtr)
  592.       return Yes;
  593.     else
  594.       return No;
  595.    case QueryAudioFunction:
  596.     if (theObject->DevQueryAudioPtr)
  597.       return Yes;
  598.     else
  599.       return No;
  600.    case QueryVideoFunction:
  601.     if (theObject->DevQueryVideoPtr)
  602.       return Yes;
  603.     else
  604.       return No;
  605.    case QueryMediumFunction:
  606.     if (theObject->DevQueryMediumPtr)
  607.       return Yes;
  608.     else
  609.       return No;
  610.    case QueryStatusFunction:
  611.     if (theObject->DevQueryStatusPtr)
  612.       return Yes;
  613.     else
  614.       return No;
  615.    case PingFunction:
  616.     if (theObject->DevPingPtr)
  617.       return Yes;
  618.     else
  619.       return No;    
  620.    case RecordFunction:
  621.     if (theObject->DevRecordPtr)
  622.       return Yes;
  623.     else
  624.       return No;    
  625.    case RecordFromToFunction:
  626.     if (theObject->DevRecordFromToPtr)
  627.       return Yes;
  628.     else
  629.       return No;    
  630.    default:
  631.     return -1;
  632.   }
  633. }
  634.  
  635.  
  636.  
  637.  
  638. /* Functions of the Video Object */
  639. /* All applications call one of the following generic Dev<Function>s ... 
  640.  * ... which call the appropriate function for the specific device. */
  641.  
  642. int 
  643.   DevPlay(VideoObject* theObject)
  644. {
  645.   if (theObject)
  646.     return ((*theObject->DevPlayPtr) (theObject));  
  647.   else
  648.   {
  649.     fprintf(stderr, "No device driver installed\n");
  650.     return -1;
  651.   }
  652.   
  653. }
  654.  
  655. int 
  656.   DevPlayFromTo(VideoObject*    theObject,
  657.         int        startFrame,
  658.         int        endFrame,
  659.         int        speed)
  660. {
  661.   if (theObject)
  662.     return ((*theObject->DevPlayFromToPtr) (theObject, startFrame, endFrame, speed));
  663.   else
  664.   {
  665.     fprintf(stderr, "No device driver installed\n");
  666.     return -1;
  667.   }
  668. }
  669.  
  670.  
  671. int 
  672.   DevFastForward(VideoObject* theObject)
  673. {
  674.   if (theObject)
  675.     return ((*theObject->DevFastForwardPtr) (theObject));
  676.   else
  677.   {
  678.     fprintf(stderr, "No device driver installed\n");
  679.     return -1;
  680.   }
  681. }
  682.  
  683.  
  684.  
  685. int 
  686.   DevReverse(VideoObject* theObject)
  687. {
  688.   if (theObject)
  689.     return ((*theObject->DevReversePtr) (theObject));
  690.   else
  691.   {
  692.     fprintf(stderr, "No device driver installed\n");
  693.     return -1;
  694.   }
  695. }
  696.  
  697.  
  698. int
  699.   DevCalcSpeed(VideoObject*    theObject,
  700.            int        value,
  701.            int        mode)
  702. {
  703.   if (theObject)
  704.     return ((*theObject->DevCalcSpeedPtr) (theObject, value, mode));
  705.   else
  706.   {
  707.     fprintf(stderr, "No device driver installed\n");
  708.     return -1;
  709.   }
  710. }
  711.  
  712.  
  713. int 
  714.   DevPlayAtSpeedDir(VideoObject*    theObject,
  715.             int            framesPerSecond,
  716.             enum Direction    direction)
  717. {
  718.   if (theObject)
  719.     return ((*theObject->DevPlayAtSpeedDirPtr) (theObject, framesPerSecond, direction));
  720.   else
  721.   {
  722.     fprintf(stderr, "No device driver installed\n");
  723.     return -1;
  724.   }
  725. }
  726.  
  727. int DevStep(VideoObject*    theObject,
  728.         enum Direction    direction)
  729. {
  730.   if (theObject)
  731.     return ((*theObject->DevStepPtr) (theObject, direction));
  732.   else
  733.   {
  734.     fprintf(stderr, "No device driver installed\n");
  735.     return -1;
  736.   }
  737. }
  738.  
  739. int DevStill(VideoObject* theObject)
  740. {
  741.   if (theObject)
  742.     return ((*theObject->DevStillPtr) (theObject));
  743.   else
  744.   {
  745.     fprintf(stderr, "No device driver installed\n");
  746.     return -1;
  747.   }
  748. }
  749.  
  750.  
  751. int DevStop(VideoObject* theObject)
  752. {
  753.   if (theObject)
  754.     return ((*theObject->DevStopPtr) (theObject));
  755.   else
  756.   {
  757.     fprintf(stderr, "No device driver installed\n");
  758.     return -1;
  759.   }
  760. }
  761.  
  762.  
  763. int DevSetDefaults(VideoObject*    theObject,
  764.            int        audio,
  765.            int        addressingMode,
  766.            int        addressDisplayOnOff,
  767.            int        displayMode)
  768. {
  769.   if (theObject)
  770.     return ((*theObject->DevSetDefaultsPtr) (theObject, audio, addressingMode, 
  771.                          addressDisplayOnOff, displayMode));
  772.   else
  773.   {
  774.     fprintf(stderr, "No device driver installed\n");
  775.     return -1;
  776.   }
  777. }
  778.  
  779.  
  780. int DevSetAudio(VideoObject*    theObject,
  781.         int        setting)
  782. {
  783.   if (theObject)
  784.     return ((*theObject->DevSetAudioPtr) (theObject, setting));
  785.   else
  786.   {
  787.     fprintf(stderr, "No device driver installed\n");
  788.     return -1;
  789.   }
  790. }
  791.  
  792.  
  793. int DevSetVideo(VideoObject*    theObject,
  794.         int        setting)
  795. {  
  796.   if (theObject)
  797.     return ((*theObject->DevSetVideoPtr) (theObject, setting));
  798.   else
  799.   {
  800.     fprintf(stderr, "No device driver installed\n");
  801.     return -1;
  802.   }
  803. }
  804.  
  805. int DevSetAddMode(VideoObject*    theObject,
  806.           int        mode)
  807. {
  808.   if (theObject)
  809.     return ((*theObject->DevSetAddModePtr) (theObject, mode));
  810.   else
  811.   {
  812.     fprintf(stderr, "No device driver installed\n");
  813.     return -1;
  814.   }
  815. }
  816.  
  817.  
  818. int DevSetAddressDisplay(VideoObject*    theObject,
  819.              int        onOff,
  820.              int        mode)
  821. {
  822.   if (theObject)
  823.     return ((*theObject->DevSetAddressDisplayPtr) (theObject, onOff, mode));
  824.   else
  825.   {
  826.     fprintf(stderr, "No device driver installed\n");
  827.     return -1;
  828.   }
  829. }
  830.  
  831.  
  832. int DevEject(VideoObject* theObject)
  833. {
  834.   if (theObject)
  835.     return ((*theObject->DevEjectPtr) (theObject));
  836.   else
  837.   {
  838.     fprintf(stderr, "No device driver installed\n");
  839.     return -1;
  840.   }
  841. }
  842.  
  843.  
  844. int DevPower(VideoObject*    theObject,
  845.          int        mode)
  846. {
  847.   if (theObject)
  848.     return ((*theObject->DevPowerPtr) (theObject, mode));
  849.   else
  850.   {
  851.     fprintf(stderr, "No device driver installed\n");
  852.     return -1;
  853.   }
  854. }
  855.  
  856.  
  857. int DevQueryFrame(VideoObject* theObject)
  858. {
  859.   if (theObject)
  860.     return ((*theObject->DevQueryFramePtr) (theObject));
  861.   else
  862.   {
  863.     fprintf(stderr, "No device driver installed\n");
  864.     return -1;
  865.   }
  866. }
  867.  
  868.  
  869. int DevQueryChapter(VideoObject* theObject)
  870. {
  871.   if (theObject)
  872.     return ((*theObject->DevQueryChapterPtr) (theObject));
  873.   else
  874.   {
  875.     fprintf(stderr, "No device driver installed\n");
  876.     return -1;
  877.   }
  878. }
  879.  
  880.  
  881. int DevQueryAudio(VideoObject* theObject)
  882. {
  883.   if (theObject)
  884.     return ((*theObject->DevQueryAudioPtr) (theObject));
  885.   else
  886.   {
  887.     fprintf(stderr, "No device driver installed\n");
  888.     return -1;
  889.   }
  890. }
  891.  
  892.  
  893. int DevQueryVideo(VideoObject* theObject)
  894. {
  895.   if (theObject)
  896.     return ((*theObject->DevQueryVideoPtr) (theObject));
  897.   else
  898.   {
  899.     fprintf(stderr, "No device driver installed\n");
  900.     return -1;
  901.   }
  902. }
  903.  
  904.  
  905. int DevQueryMedium(VideoObject*    theObject,
  906.            char*    result)
  907. {
  908.   if (theObject)
  909.     return ((*theObject->DevQueryMediumPtr) (theObject, result));
  910.   else
  911.   {
  912.     fprintf(stderr, "No device driver installed\n");
  913.     return -1;
  914.   }
  915. }
  916.  
  917.  
  918. int DevQueryStatus(VideoObject*    theObject)
  919. {
  920.   if (theObject)
  921.     return ((*theObject->DevQueryStatusPtr) (theObject));
  922.   else
  923.   {
  924.     fprintf(stderr, "No device driver installed\n");
  925.     return -1;
  926.   }
  927. }
  928.  
  929.  
  930. int DevPing(VideoObject* theObject)
  931. {
  932.   if (theObject)
  933.     return ((*theObject->DevPingPtr) (theObject));
  934.   else
  935.   {
  936.     fprintf(stderr, "No device driver installed\n");
  937.     return -1;
  938.   }
  939. }
  940.  
  941.  
  942. int 
  943.   DevRecord(VideoObject* theObject)
  944. {
  945.   if (theObject)
  946.     return ((*theObject->DevRecordPtr) (theObject));
  947.   else
  948.   {
  949.     fprintf(stderr, "No Record function installed.\n");
  950.     return -1;
  951.   }
  952. }                                    /* end function DevRecord */
  953.  
  954.  
  955.  
  956. int 
  957.   DevRecordFromTo(VideoObject* theObject,
  958.           int startFrame,
  959.           int endFrame,
  960.           int speed)
  961. {
  962.   if (theObject)
  963.     return ((*theObject->DevRecordFromToPtr) (theObject, startFrame, endFrame, speed));
  964.   else
  965.   {
  966.     fprintf(stderr, "No RecordFromTo function installed.\n");
  967.     return -1;
  968.   }
  969. }                                    /* end function DevRecordFromTo */
  970.  
  971.  
  972. /* Default Functions of the Video Object */
  973. /* Functions that are not implemented for the driver and for ...
  974.  * ... which no dummy function has been written by the ...
  975.  * ... the application programmer will use the default ...
  976.  * ... functions.
  977.  */
  978.  
  979. int 
  980.   DefaultPlay(VideoObject* theObject)
  981. {
  982.   fprintf(stderr, "DevPlay has not been implemented.\n");
  983.   return Ok;
  984. }
  985.  
  986. int 
  987.   DefaultPlayFromTo(VideoObject*    theObject,
  988.             int            startFrame,
  989.             int            endFrame,
  990.             int            speed)
  991. {
  992.   fprintf(stderr, "DevPlayFromTo has not been implemented.\n");
  993.   return Ok;
  994. }
  995.  
  996.  
  997. int 
  998.   DefaultFastForward(VideoObject* theObject)
  999. {
  1000.   fprintf(stderr, "DevFastForward has not been implemented.\n");
  1001.   return Ok;
  1002. }
  1003.  
  1004.  
  1005.  
  1006. int 
  1007.   DefaultReverse(VideoObject* theObject)
  1008. {
  1009.   fprintf(stderr, "DevReverse has not been implemented.\n");
  1010.   return Ok;
  1011. }
  1012.  
  1013.  
  1014. int
  1015.   DefaultCalcSpeed(VideoObject*    theObject,
  1016.            int        value,
  1017.            int        mode)
  1018. {
  1019.   fprintf(stderr, "DevCalcSpeed has not been implemented.\n");
  1020.   return Ok;
  1021. }
  1022.  
  1023.  
  1024. int 
  1025.   DefaultPlayAtSpeedDir(VideoObject*    theObject,
  1026.             int        framesPerSecond,
  1027.             enum Direction    direction)
  1028. {
  1029.   fprintf(stderr, "DevPlayAtSpeedDir has not been implemented.\n");
  1030.   return Ok;
  1031. }
  1032.  
  1033.  
  1034. int DefaultStep(VideoObject*    theObject,
  1035.         enum Direction    direction)
  1036. {
  1037.   fprintf(stderr, "DevStep has not been implemented.\n");
  1038.   return Ok;
  1039. }
  1040.  
  1041.  
  1042. int DefaultStill(VideoObject* theObject)
  1043. {
  1044.   fprintf(stderr, "DevStill has not been implemented.\n");
  1045.   return Ok;
  1046. }
  1047.  
  1048. int DefaultStop(VideoObject* theObject)
  1049. {
  1050.   fprintf(stderr, "DevStop has not been implemented.\n");
  1051.   return Ok;
  1052. }
  1053.  
  1054. int DefaultSetDefaults(VideoObject*    theObject,
  1055.                int        audio,
  1056.                int        addressingMode,
  1057.                int        addressDisplayOnOff,
  1058.                int        displayMode)
  1059. {
  1060.   fprintf(stderr, "DevSetDefaults has not been implemented.\n");
  1061.   return Ok;
  1062. }
  1063.  
  1064. int DefaultSetAudio(VideoObject*    theObject,
  1065.             int            setting)
  1066. {
  1067.   fprintf(stderr, "DevSetAudio has not been implemented.\n");
  1068.   return Ok;
  1069. }
  1070.  
  1071. int DefaultSetVideo(VideoObject*    theObject,
  1072.             int            setting)
  1073. {  
  1074.   fprintf(stderr, "DevSetVideo has not been implemented.\n");
  1075.   return Ok;
  1076. }
  1077.  
  1078. int DefaultSetAddMode(VideoObject*    theObject,
  1079.               int         mode)
  1080. {
  1081.   fprintf(stderr, "DevSetAddMode has not been implemented.\n");
  1082.   return Ok;
  1083. }
  1084.  
  1085. int DefaultSetAddressDisplay(VideoObject*    theObject,
  1086.                  int        onOff,
  1087.                  int        mode)
  1088. {
  1089.   fprintf(stderr, "DevSetAddressDisplay has not been implemented.\n");
  1090.   return Ok;
  1091. }
  1092.  
  1093.  
  1094.  
  1095. int DefaultEject(VideoObject* theObject)
  1096. {
  1097.   fprintf(stderr, "DevEject has not been implemented.\n");
  1098.   return Ok;
  1099. }
  1100.  
  1101.  
  1102. int DefaultPower(VideoObject*    theObject,
  1103.          int        mode)
  1104. {
  1105.   fprintf(stderr, "DevPower has not been implemented.\n");
  1106.   return Ok;
  1107. }
  1108.  
  1109.  
  1110. int DefaultQueryFrame(VideoObject* theObject)
  1111. {
  1112.   fprintf(stderr, "DevQueryFrame has not been implemented.\n");
  1113.   return Ok;
  1114. }
  1115.  
  1116. int DefaultQueryChapter(VideoObject* theObject)
  1117. {
  1118.   fprintf(stderr, "DevQueryChapter has not been implemented.\n");
  1119.   return Ok;
  1120. }
  1121.  
  1122. int DefaultQueryAudio(VideoObject* theObject)
  1123. {
  1124.   fprintf(stderr, "DevQueryAudio has not been implemented.\n");
  1125.   return Ok;
  1126. }
  1127.  
  1128. int DefaultQueryVideo(VideoObject* theObject)
  1129. {
  1130.   fprintf(stderr, "DevQueryVideo has not been implemented.\n");
  1131.   return Ok;
  1132. }
  1133.  
  1134. int DefaultQueryMedium(VideoObject*    theObject,
  1135.                char*        result)
  1136. {
  1137.   fprintf(stderr, "DevQueryMedium has not been implemented.\n");
  1138.   return Ok;
  1139. }
  1140.  
  1141. int DefaultQueryStatus(VideoObject* theObject)
  1142. {
  1143.   fprintf(stderr, "DevQueryStatus has not been implemented.\n");
  1144.   return Ok;
  1145. }
  1146.  
  1147. int DefaultPing(VideoObject* theObject)
  1148. {
  1149.   fprintf(stderr, "DevPing has not been implemented.\n");
  1150.   return Ok;
  1151. }
  1152.  
  1153.  
  1154.  
  1155. int DefaultRecord(VideoObject* theObject)
  1156. {
  1157.   fprintf(stderr, "DevRecord has not been implemented.\n");
  1158.   return Ok;
  1159. }
  1160.  
  1161.  
  1162. int 
  1163.   DefaultRecordFromTo(VideoObject* theObject,
  1164.               int startFrame,
  1165.               int endFrame,
  1166.               int speed)
  1167. {
  1168.   fprintf(stderr, "DevRecordFromTo has not been implemented.\n");
  1169.   return Ok;
  1170. }
  1171.